// -----
// The `timezoneJS.Date` object gives you full-blown timezone support, independent from the timezone set on the end-user's machine running the browser. It uses the Olson zoneinfo files for its timezone data.
//
// The constructor function and setter methods use proxy JavaScript Date objects behind the scenes, so you can use strings like '10/22/2006' with the constructor. You also get the same sensible wraparound behavior with numeric parameters (like setting a value of 14 for the month wraps around to the next March).
//
// The other significant difference from the built-in JavaScript Date is that `timezoneJS.Date` also has named properties that store the values of year, month, date, etc., so it can be directly serialized to JSON and used for data transfer.

/*
 * Copyright 2010 Matthew Eernisse (mde@fleegix.org)
 * and Open Source Applications Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Credits: Ideas included from incomplete JS implementation of Olson
 * parser, "XMLDAte" by Philippe Goetz (philippe.goetz@wanadoo.fr)
 *
 * Contributions:
 * Jan Niehusmann
 * Ricky Romero
 * Preston Hunt (prestonhunt@gmail.com)
 * Dov. B Katz (dov.katz@morganstanley.com)
 * Peter Bergström (pbergstr@mac.com)
 * Long Ho
 */
(function () {
    // Standard initialization stuff to make sure the library is
    // usable on both client and server (node) side.

    var root = this;

    var timezoneJS;
    if (typeof exports !== 'undefined') {
        timezoneJS = exports;
    } else {
        timezoneJS = root.timezoneJS = {};
    }

    timezoneJS.VERSION = '1.0.0';

    // Grab the ajax library from global context.
    // This can be jQuery, Zepto or fleegix.
    // You can also specify your own transport mechanism by declaring
    // `timezoneJS.timezone.transport` to a `function`. More details will follow
    var $ = root.$ || root.jQuery || root.Zepto
        , fleegix = root.fleegix
    // Declare constant list of days and months. Unfortunately this doesn't leave room for i18n due to the Olson data being in English itself
        , DAYS = timezoneJS.Days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
        , MONTHS = timezoneJS.Months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
        , SHORT_MONTHS = {}
        , SHORT_DAYS = {}
        , EXACT_DATE_TIME = {}
        , TZ_REGEXP = new RegExp('^[a-zA-Z]+/');

    //`{ "Jan": 0, "Feb": 1, "Mar": 2, "Apr": 3, "May": 4, "Jun": 5, "Jul": 6, "Aug": 7, "Sep": 8, "Oct": 9, "Nov": 10, "Dec": 11 }`
    for (var i = 0; i < MONTHS.length; i++) {
        SHORT_MONTHS[MONTHS[i].substr(0, 3)] = i;
    }

    //`{ "Sun": 0, "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6 }`
    for (i = 0; i < DAYS.length; i++) {
        SHORT_DAYS[DAYS[i].substr(0, 3)] = i;
    }


    //Handle array indexOf in IE
    if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function (el) {
            for (var i = 0; i < this.length; i++) {
                if (el === this[i]) return i;
            }
            return -1;
        }
    }

    // Format a number to the length = digits. For ex:
    //
    // `_fixWidth(2, 2) = '02'`
    //
    // `_fixWidth(1998, 2) = '98'`
    //
    // This is used to pad numbers in converting date to string in ISO standard.
    var _fixWidth = function (number, digits) {
        if (typeof number !== "number") {
            throw "not a number: " + number;
        }
        var s = number.toString();
        if (number.length > digits) {
            return number.substr(number.length - digits, number.length);
        }
        while (s.length < digits) {
            s = '0' + s;
        }
        return s;
    };

    // Abstraction layer for different transport layers, including fleegix/jQuery/Zepto
    //
    // Object `opts` include
    //
    // - `url`: url to ajax query
    //
    // - `async`: true for asynchronous, false otherwise. If false, return value will be response from URL. This is true by default
    //
    // - `success`: success callback function
    //
    // - `error`: error callback function
    // Returns response from URL if async is false, otherwise the AJAX request object itself
    var _transport = function (opts) {
        if ((!fleegix || typeof fleegix.xhr === 'undefined') && (!$ || typeof $.ajax === 'undefined')) {
            throw new Error('Please use the Fleegix.js XHR module, jQuery ajax, Zepto ajax, or define your own transport mechanism for downloading zone files.');
        }
        if (!opts) return;
        if (!opts.url) throw new Error('URL must be specified');
        if (!('async' in opts)) opts.async = true;
        if (!opts.async) {
            return fleegix && fleegix.xhr
                ? fleegix.xhr.doReq({ url: opts.url, async: false })
                : $.ajax({ url: opts.url, async: false }).responseText;
        }
        return fleegix && fleegix.xhr
            ? fleegix.xhr.send({
            url: opts.url,
            method: 'get',
            handleSuccess: opts.success,
            handleErr: opts.error
        })
            : $.ajax({
            url: opts.url,
            dataType: 'text',
            method: 'GET',
            error: opts.error,
            success: opts.success
        });
    };

    // Constructor, which is similar to that of the native Date object itself
    timezoneJS.Date = function () {
        var args = Array.prototype.slice.apply(arguments)
            , dt = null
            , tz = null
            , arr = [];


        //We support several different constructors, including all the ones from `Date` object
        // with a timezone string at the end.
        //
        //- `[tz]`: Returns object with time in `tz` specified.
        //
        // - `utcMillis`, `[tz]`: Return object with UTC time = `utcMillis`, in `tz`.
        //
        // - `Date`, `[tz]`: Returns object with UTC time = `Date.getTime()`, in `tz`.
        //
        // - `year, month, [date,] [hours,] [minutes,] [seconds,] [millis,] [tz]: Same as `Date` object
        // with tz.
        //
        // - `Array`: Can be any combo of the above.
        //
        //If 1st argument is an array, we can use it as a list of arguments itself
        if (Object.prototype.toString.call(args[0]) === '[object Array]') {
            args = args[0];
        }
        if (typeof args[args.length - 1] === 'string' && TZ_REGEXP.test(args[args.length - 1])) {
            tz = args.pop();
        }
        switch (args.length) {
            case 0:
                dt = new Date();
                break;
            case 1:
                dt = new Date(args[0]);
                break;
            default:
                for (var i = 0; i < 7; i++) {
                    arr[i] = args[i] || 0;
                }
                dt = new Date(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]);
                break;
        }

        this._useCache = false;
        this._tzInfo = {};
        this._day = 0;
        this.year = 0;
        this.month = 0;
        this.date = 0;
        this.hours = 0;
        this.minutes = 0;
        this.seconds = 0;
        this.milliseconds = 0;
        this.timezone = tz || null;
        //Tricky part:
        // For the cases where there are 1/2 arguments: `timezoneJS.Date(millis, [tz])` and `timezoneJS.Date(Date, [tz])`. The
        // Date `dt` created should be in UTC. Thus the way I detect such cases is to determine if `arr` is not populated & `tz`
        // is specified. Because if `tz` is not specified, `dt` can be in local time.
        if (arr.length) {
            this.setFromDateObjProxy(dt);
        } else {
            this.setFromTimeProxy(dt.getTime(), tz);
        }
    };

    // Implements most of the native Date object
    timezoneJS.Date.prototype = {
        getDate: function () {
            return this.date;
        },
        getDay: function () {
            return this._day;
        },
        getFullYear: function () {
            return this.year;
        },
        getMonth: function () {
            return this.month;
        },
        getYear: function () {
            return this.year;
        },
        getHours: function () {
            return this.hours;
        },
        getMilliseconds: function () {
            return this.milliseconds;
        },
        getMinutes: function () {
            return this.minutes;
        },
        getSeconds: function () {
            return this.seconds;
        },
        getUTCDate: function () {
            return this.getUTCDateProxy().getUTCDate();
        },
        getUTCDay: function () {
            return this.getUTCDateProxy().getUTCDay();
        },
        getUTCFullYear: function () {
            return this.getUTCDateProxy().getUTCFullYear();
        },
        getUTCHours: function () {
            return this.getUTCDateProxy().getUTCHours();
        },
        getUTCMilliseconds: function () {
            return this.getUTCDateProxy().getUTCMilliseconds();
        },
        getUTCMinutes: function () {
            return this.getUTCDateProxy().getUTCMinutes();
        },
        getUTCMonth: function () {
            return this.getUTCDateProxy().getUTCMonth();
        },
        getUTCSeconds: function () {
            return this.getUTCDateProxy().getUTCSeconds();
        },
        // Time adjusted to user-specified timezone
        getTime: function () {
            return this._timeProxy + (this.getTimezoneOffset() * 60 * 1000);
        },
        getTimezone: function () {
            return this.timezone;
        },
        getTimezoneOffset: function () {
            return this.getTimezoneInfo().tzOffset;
        },
        getTimezoneAbbreviation: function () {
            return this.getTimezoneInfo().tzAbbr;
        },
        getTimezoneInfo: function () {
            if (this._useCache) return this._tzInfo;
            var res;
            // If timezone is specified, get the correct timezone info based on the Date given
            if (this.timezone) {
                res = this.timezone === 'Etc/UTC' || this.timezone === 'Etc/GMT'
                    ? { tzOffset: 0, tzAbbr: 'UTC' }
                    : timezoneJS.timezone.getTzInfo(this._timeProxy, this.timezone);
            }
            // If no timezone was specified, use the local browser offset
            else {
                res = { tzOffset: this.getLocalOffset(), tzAbbr: null };
            }
            this._tzInfo = res;
            this._useCache = true;
            return res
        },
        getUTCDateProxy: function () {
            var dt = new Date(this._timeProxy);
            dt.setUTCMinutes(dt.getUTCMinutes() + this.getTimezoneOffset());
            return dt;
        },
        setDate: function (n) {
            this.setAttribute('date', n);
        },
        setFullYear: function (n) {
            this.setAttribute('year', n);
        },
        setMonth: function (n) {
            this.setAttribute('month', n);
        },
        setYear: function (n) {
            this.setUTCAttribute('year', n);
        },
        setHours: function (n) {
            this.setAttribute('hours', n);
        },
        setMilliseconds: function (n) {
            this.setAttribute('milliseconds', n);
        },
        setMinutes: function (n) {
            this.setAttribute('minutes', n);
        },
        setSeconds: function (n) {
            this.setAttribute('seconds', n);
        },
        setTime: function (n) {
            if (isNaN(n)) {
                throw new Error('Units must be a number.');
            }
            this.setFromTimeProxy(n, this.timezone);
        },
        setUTCDate: function (n) {
            this.setUTCAttribute('date', n);
        },
        setUTCFullYear: function (n) {
            this.setUTCAttribute('year', n);
        },
        setUTCHours: function (n) {
            this.setUTCAttribute('hours', n);
        },
        setUTCMilliseconds: function (n) {
            this.setUTCAttribute('milliseconds', n);
        },
        setUTCMinutes: function (n) {
            this.setUTCAttribute('minutes', n);
        },
        setUTCMonth: function (n) {
            this.setUTCAttribute('month', n);
        },
        setUTCSeconds: function (n) {
            this.setUTCAttribute('seconds', n);
        },
        setFromDateObjProxy: function (dt) {
            this.year = dt.getFullYear();
            this.month = dt.getMonth();
            this.date = dt.getDate();
            this.hours = dt.getHours();
            this.minutes = dt.getMinutes();
            this.seconds = dt.getSeconds();
            this.milliseconds = dt.getMilliseconds();
            this._day = dt.getDay();
            this._dateProxy = dt;
            this._timeProxy = Date.UTC(this.year, this.month, this.date, this.hours, this.minutes, this.seconds, this.milliseconds);
            this._useCache = false;
        },
        setFromTimeProxy: function (utcMillis, tz) {
            var dt = new Date(utcMillis);
            var tzOffset;
            tzOffset = tz ? timezoneJS.timezone.getTzInfo(dt, tz).tzOffset : dt.getTimezoneOffset();
            dt.setTime(utcMillis + (dt.getTimezoneOffset() - tzOffset) * 60000);
            this.setFromDateObjProxy(dt);
        },
        setAttribute: function (unit, n) {
            if (isNaN(n)) {
                throw new Error('Units must be a number.');
            }
            var dt = this._dateProxy;
            var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
            dt['set' + meth](n);
            this.setFromDateObjProxy(dt);
        },
        setUTCAttribute: function (unit, n) {
            if (isNaN(n)) {
                throw new Error('Units must be a number.');
            }
            var meth = unit === 'year' ? 'FullYear' : unit.substr(0, 1).toUpperCase() + unit.substr(1);
            var dt = this.getUTCDateProxy();
            dt['setUTC' + meth](n);
            dt.setUTCMinutes(dt.getUTCMinutes() - this.getTimezoneOffset());
            this.setFromTimeProxy(dt.getTime() + this.getTimezoneOffset() * 60000, this.timezone);
        },
        setTimezone: function (tz) {
            var previousOffset = this.getTimezoneInfo().tzOffset;
            this.timezone = tz;
            this._useCache = false;
            // Set UTC minutes offsets by the delta of the two timezones
            this.setUTCMinutes(this.getUTCMinutes() - this.getTimezoneInfo().tzOffset + previousOffset);
        },
        removeTimezone: function () {
            this.timezone = null;
            this._useCache = false;
        },
        valueOf: function () {
            return this.getTime();
        },
        clone: function () {
            return this.timezone ? new timezoneJS.Date(this.getTime(), this.timezone) : new timezoneJS.Date(this.getTime());
        },
        toGMTString: function () {
            return this.toString('EEE, dd MMM yyyy HH:mm:ss Z', 'Etc/GMT');
        },
        toLocaleString: function () {
        },
        toLocaleDateString: function () {
        },
        toLocaleTimeString: function () {
        },
        toSource: function () {
        },
        toISOString: function () {
            return this.toString('yyyy-MM-ddTHH:mm:ss.SSS', 'Etc/UTC') + 'Z';
        },
        toJSON: function () {
            return this.toISOString();
        },
        // Allows different format following ISO8601 format:
        toString: function (format, tz) {
            // Default format is the same as toISOString
            if (!format) format = 'yyyy-MM-dd HH:mm:ss';
            var result = format;
            var tzInfo = tz ? timezoneJS.timezone.getTzInfo(this.getTime(), tz) : this.getTimezoneInfo();
            var _this = this;
            // If timezone is specified, get a clone of the current Date object and modify it
            if (tz) {
                _this = this.clone();
                _this.setTimezone(tz);
            }
            var hours = _this.getHours();
            return result
                // fix the same characters in Month names
                .replace(/a+/g, function () {
                    return 'k';
                })
                // `y`: year
                .replace(/y+/g, function (token) {
                    return _fixWidth(_this.getFullYear(), token.length);
                })
                // `d`: date
                .replace(/d+/g, function (token) {
                    return _fixWidth(_this.getDate(), token.length);
                })
                // `m`: minute
                .replace(/m+/g, function (token) {
                    return _fixWidth(_this.getMinutes(), token.length);
                })
                // `s`: second
                .replace(/s+/g, function (token) {
                    return _fixWidth(_this.getSeconds(), token.length);
                })
                // `S`: millisecond
                .replace(/S+/g, function (token) {
                    return _fixWidth(_this.getMilliseconds(), token.length);
                })
                // `M`: month. Note: `MM` will be the numeric representation (e.g February is 02) but `MMM` will be text representation (e.g February is Feb)
                .replace(/M+/g, function (token) {
                    var _month = _this.getMonth(),
                        _len = token.length;
                    if (_len > 3) {
                        return timezoneJS.Months[_month];
                    } else if (_len > 2) {
                        return timezoneJS.Months[_month].substring(0, _len);
                    }
                    return _fixWidth(_month + 1, _len);
                })
                // `k`: AM/PM
                .replace(/k+/g, function () {
                    if (hours >= 12) {
                        if (hours > 12) {
                            hours -= 12;
                        }
                        return 'PM';
                    }
                    return 'AM';
                })
                // `H`: hour
                .replace(/H+/g, function (token) {
                    return _fixWidth(hours, token.length);
                })
                // `E`: day
                .replace(/E+/g, function (token) {
                    return DAYS[_this.getDay()].substring(0, token.length);
                })
                // `Z`: timezone abbreviation
                .replace(/Z+/gi, function () {
                    return tzInfo.tzAbbr;
                });
        },
        toUTCString: function () {
            return this.toGMTString();
        },
        civilToJulianDayNumber: function (y, m, d) {
            var a;
            // Adjust for zero-based JS-style array
            m++;
            if (m > 12) {
                a = parseInt(m / 12, 10);
                m = m % 12;
                y += a;
            }
            if (m <= 2) {
                y -= 1;
                m += 12;
            }
            a = Math.floor(y / 100);
            var b = 2 - a + Math.floor(a / 4)
                , jDt = Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 * (m + 1)) + d + b - 1524;
            return jDt;
        },
        getLocalOffset: function () {
            return this._dateProxy.getTimezoneOffset();
        }
    };


    timezoneJS.timezone = new function () {
        var _this = this
            , regionMap = {'Etc': 'etcetera', 'EST': 'northamerica', 'MST': 'northamerica', 'HST': 'northamerica', 'EST5EDT': 'northamerica', 'CST6CDT': 'northamerica', 'MST7MDT': 'northamerica', 'PST8PDT': 'northamerica', 'America': 'northamerica', 'Pacific': 'australasia', 'Atlantic': 'europe', 'Africa': 'africa', 'Indian': 'africa', 'Antarctica': 'antarctica', 'Asia': 'asia', 'Australia': 'australasia', 'Europe': 'europe', 'WET': 'europe', 'CET': 'europe', 'MET': 'europe', 'EET': 'europe'}
            , regionExceptions = {'Pacific/Honolulu': 'northamerica', 'Atlantic/Bermuda': 'northamerica', 'Atlantic/Cape_Verde': 'africa', 'Atlantic/St_Helena': 'africa', 'Indian/Kerguelen': 'antarctica', 'Indian/Chagos': 'asia', 'Indian/Maldives': 'asia', 'Indian/Christmas': 'australasia', 'Indian/Cocos': 'australasia', 'America/Danmarkshavn': 'europe', 'America/Scoresbysund': 'europe', 'America/Godthab': 'europe', 'America/Thule': 'europe', 'Asia/Yekaterinburg': 'europe', 'Asia/Omsk': 'europe', 'Asia/Novosibirsk': 'europe', 'Asia/Krasnoyarsk': 'europe', 'Asia/Irkutsk': 'europe', 'Asia/Yakutsk': 'europe', 'Asia/Vladivostok': 'europe', 'Asia/Sakhalin': 'europe', 'Asia/Magadan': 'europe', 'Asia/Kamchatka': 'europe', 'Asia/Anadyr': 'europe', 'Africa/Ceuta': 'europe', 'America/Argentina/Buenos_Aires': 'southamerica', 'America/Argentina/Cordoba': 'southamerica', 'America/Argentina/Tucuman': 'southamerica', 'America/Argentina/La_Rioja': 'southamerica', 'America/Argentina/San_Juan': 'southamerica', 'America/Argentina/Jujuy': 'southamerica', 'America/Argentina/Catamarca': 'southamerica', 'America/Argentina/Mendoza': 'southamerica', 'America/Argentina/Rio_Gallegos': 'southamerica', 'America/Argentina/Ushuaia': 'southamerica', 'America/Aruba': 'southamerica', 'America/La_Paz': 'southamerica', 'America/Noronha': 'southamerica', 'America/Belem': 'southamerica', 'America/Fortaleza': 'southamerica', 'America/Recife': 'southamerica', 'America/Araguaina': 'southamerica', 'America/Maceio': 'southamerica', 'America/Bahia': 'southamerica', 'America/Sao_Paulo': 'southamerica', 'America/Campo_Grande': 'southamerica', 'America/Cuiaba': 'southamerica', 'America/Porto_Velho': 'southamerica', 'America/Boa_Vista': 'southamerica', 'America/Manaus': 'southamerica', 'America/Eirunepe': 'southamerica', 'America/Rio_Branco': 'southamerica', 'America/Santiago': 'southamerica', 'Pacific/Easter': 'southamerica', 'America/Bogota': 'southamerica', 'America/Curacao': 'southamerica', 'America/Guayaquil': 'southamerica', 'Pacific/Galapagos': 'southamerica', 'Atlantic/Stanley': 'southamerica', 'America/Cayenne': 'southamerica', 'America/Guyana': 'southamerica', 'America/Asuncion': 'southamerica', 'America/Lima': 'southamerica', 'Atlantic/South_Georgia': 'southamerica', 'America/Paramaribo': 'southamerica', 'America/Port_of_Spain': 'southamerica', 'America/Montevideo': 'southamerica', 'America/Caracas': 'southamerica'};

        function invalidTZError(t) {
            throw new Error('Timezone "' + t + '" is either incorrect, or not loaded in the timezone registry.');
        }

        function builtInLoadZoneFile(fileName, opts) {
            var url = _this.zoneFileBasePath + '/' + fileName;
            return !opts || !opts.async
                ? _this.parseZones(_this.transport({ url: url, async: false }))
                : _this.transport({
                async: true,
                url: url,
                success: function (str) {
                    if (_this.parseZones(str) && typeof opts.callback === 'function') {
                        opts.callback();
                    }
                    return true;
                },
                error: function () {
                    throw new Error('Error retrieving "' + url + '" zoneinfo files');
                }
            });
        }

        function getRegionForTimezone(tz) {
            var exc = regionExceptions[tz]
                , reg
                , ret;
            if (exc) return exc;
            reg = tz.split('/')[0];
            ret = regionMap[reg];
            // If there's nothing listed in the main regions for this TZ, check the 'backward' links
            if (ret) return ret;
            var link = _this.zones[tz];
            if (typeof link === 'string') {
                return getRegionForTimezone(link);
            }
            // Backward-compat file hasn't loaded yet, try looking in there
            if (!_this.loadedZones.backward) {
                // This is for obvious legacy zones (e.g., Iceland) that don't even have a prefix like "America/" that look like normal zones
                _this.loadZoneFile('backward');
                return getRegionForTimezone(tz);
            }
            invalidTZError(tz);
        }

        function parseTimeString(str) {
            var pat = /(\d+)(?::0*(\d*))?(?::0*(\d*))?([wsugz])?$/;
            var hms = str.match(pat);
            hms[1] = parseInt(hms[1], 10);
            hms[2] = hms[2] ? parseInt(hms[2], 10) : 0;
            hms[3] = hms[3] ? parseInt(hms[3], 10) : 0;

            return hms;
        }

        function processZone(z) {
            if (!z[3]) {
                return;
            }
            var yea = parseInt(z[3], 10);
            var mon = 11;
            var dat = 31;
            if (z[4]) {
                mon = SHORT_MONTHS[z[4].substr(0, 3)];
                dat = parseInt(z[5], 10) || 1;
            }
            var string = z[6] ? z[6] : '00:00:00'
                , t = parseTimeString(string);
            return [yea, mon, dat, t[1], t[2], t[3]];
        }

        function getZone(dt, tz) {
            var utcMillis = typeof dt === 'number' ? dt : new Date(dt).getTime();
            var t = tz;
            var zoneList = _this.zones[t];
            // Follow links to get to an actual zone
            while (typeof zoneList === "string") {
                t = zoneList;
                zoneList = _this.zones[t];
            }
            if (!zoneList) {
                // Backward-compat file hasn't loaded yet, try looking in there
                if (!_this.loadedZones.backward) {
                    //This is for backward entries like "America/Fort_Wayne" that
                    // getRegionForTimezone *thinks* it has a region file and zone
                    // for (e.g., America => 'northamerica'), but in reality it's a
                    // legacy zone we need the backward file for.
                    _this.loadZoneFile('backward');
                    return getZone(dt, tz);
                }
                invalidTZError(t);
            }
            if (zoneList.length === 0) {
                throw new Error('No Zone found for "' + tz + '" on ' + dt);
            }
            //Do backwards lookup since most use cases deal with newer dates.
            for (var i = zoneList.length - 1; i >= 0; i--) {
                var z = zoneList[i];
                if (z[3] && utcMillis > z[3]) break;
            }
            return zoneList[i + 1];
        }

        function getBasicOffset(time) {
            var off = parseTimeString(time)
                , adj = time.indexOf('-') === 0 ? -1 : 1;
            off = adj * (((off[1] * 60 + off[2]) * 60 + off[3]) * 1000);
            return off / 60 / 1000;
        }

        //if isUTC is true, date is given in UTC, otherwise it's given
        // in local time (ie. date.getUTC*() returns local time components)
        function getRule(dt, zone, isUTC) {
            var date = typeof dt === 'number' ? new Date(dt) : dt;
            var ruleset = zone[1];
            var basicOffset = zone[0];

            //Convert a date to UTC. Depending on the 'type' parameter, the date
            // parameter may be:
            //
            // - `u`, `g`, `z`: already UTC (no adjustment).
            //
            // - `s`: standard time (adjust for time zone offset but not for DST)
            //
            // - `w`: wall clock time (adjust for both time zone and DST offset).
            //
            // DST adjustment is done using the rule given as third argument.
            var convertDateToUTC = function (date, type, rule) {
                var offset = 0;

                if (type === 'u' || type === 'g' || type === 'z') { // UTC
                    offset = 0;
                } else if (type === 's') { // Standard Time
                    offset = basicOffset;
                } else if (type === 'w' || !type) { // Wall Clock Time
                    offset = getAdjustedOffset(basicOffset, rule);
                } else {
                    throw("unknown type " + type);
                }
                offset *= 60 * 1000; // to millis

                return new Date(date.getTime() + offset);
            };

            //Step 1:  Find applicable rules for this year.
            //
            //Step 2:  Sort the rules by effective date.
            //
            //Step 3:  Check requested date to see if a rule has yet taken effect this year.  If not,
            //
            //Step 4:  Get the rules for the previous year.  If there isn't an applicable rule for last year, then
            // there probably is no current time offset since they seem to explicitly turn off the offset
            // when someone stops observing DST.
            //
            // FIXME if this is not the case and we'll walk all the way back (ugh).
            //
            //Step 5:  Sort the rules by effective date.
            //Step 6:  Apply the most recent rule before the current time.
            var convertRuleToExactDateAndTime = function (yearAndRule, prevRule) {
                var year = yearAndRule[0]
                    , rule = yearAndRule[1];
                // Assume that the rule applies to the year of the given date.

                var hms = rule[5];
                var effectiveDate;

                if (!EXACT_DATE_TIME[year])
                    EXACT_DATE_TIME[year] = {};

                // Result for given parameters is already stored
                if (EXACT_DATE_TIME[year][rule])
                    effectiveDate = EXACT_DATE_TIME[year][rule];
                else {
                    //If we have a specific date, use that!
                    if (!isNaN(rule[4])) {
                        effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4], hms[1], hms[2], hms[3], 0));
                    }
                    //Let's hunt for the date.
                    else {
                        var targetDay
                            , operator;
                        //Example: `lastThu`
                        if (rule[4].substr(0, 4) === "last") {
                            // Start at the last day of the month and work backward.
                            effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]] + 1, 1, hms[1] - 24, hms[2], hms[3], 0));
                            targetDay = SHORT_DAYS[rule[4].substr(4, 3)];
                            operator = "<=";
                        }
                        //Example: `Sun>=15`
                        else {
                            //Start at the specified date.
                            effectiveDate = new Date(Date.UTC(year, SHORT_MONTHS[rule[3]], rule[4].substr(5), hms[1], hms[2], hms[3], 0));
                            targetDay = SHORT_DAYS[rule[4].substr(0, 3)];
                            operator = rule[4].substr(3, 2);
                        }
                        var ourDay = effectiveDate.getUTCDay();
                        //Go forwards.
                        if (operator === ">=") {
                            effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay + ((targetDay < ourDay) ? 7 : 0)));
                        }
                        //Go backwards.  Looking for the last of a certain day, or operator is "<=" (less likely).
                        else {
                            effectiveDate.setUTCDate(effectiveDate.getUTCDate() + (targetDay - ourDay - ((targetDay > ourDay) ? 7 : 0)));
                        }
                    }
                    EXACT_DATE_TIME[year][rule] = effectiveDate;
                }


                //If previous rule is given, correct for the fact that the starting time of the current
                // rule may be specified in local time.
                if (prevRule) {
                    effectiveDate = convertDateToUTC(effectiveDate, hms[4], prevRule);
                }
                return effectiveDate;
            };

            var findApplicableRules = function (year, ruleset) {
                var applicableRules = [];
                for (var i = 0; ruleset && i < ruleset.length; i++) {
                    //Exclude future rules.
                    if (ruleset[i][0] <= year &&
                        (
                            // Date is in a set range.
                            ruleset[i][1] >= year ||
                                // Date is in an "only" year.
                                (ruleset[i][0] === year && ruleset[i][1] === "only") ||
                                //We're in a range from the start year to infinity.
                                ruleset[i][1] === "max"
                            )
                        ) {
                        //It's completely okay to have any number of matches here.
                        // Normally we should only see two, but that doesn't preclude other numbers of matches.
                        // These matches are applicable to this year.
                        applicableRules.push([year, ruleset[i]]);
                    }
                }
                return applicableRules;
            };

            var compareDates = function (a, b, prev) {
                var year, rule;
                if (a.constructor !== Date) {
                    year = a[0];
                    rule = a[1];
                    a = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule])
                        ? EXACT_DATE_TIME[year][rule]
                        : convertRuleToExactDateAndTime(a, prev);
                } else if (prev) {
                    a = convertDateToUTC(a, isUTC ? 'u' : 'w', prev);
                }
                if (b.constructor !== Date) {
                    year = b[0];
                    rule = b[1];
                    b = (!prev && EXACT_DATE_TIME[year] && EXACT_DATE_TIME[year][rule]) ? EXACT_DATE_TIME[year][rule]
                        : convertRuleToExactDateAndTime(b, prev);
                } else if (prev) {
                    b = convertDateToUTC(b, isUTC ? 'u' : 'w', prev);
                }
                a = Number(a);
                b = Number(b);
                return a - b;
            };

            var year = date.getUTCFullYear();
            var applicableRules;

            applicableRules = findApplicableRules(year, _this.rules[ruleset]);
            applicableRules.push(date);
            //While sorting, the time zone in which the rule starting time is specified
            // is ignored. This is ok as long as the timespan between two DST changes is
            // larger than the DST offset, which is probably always true.
            // As the given date may indeed be close to a DST change, it may get sorted
            // to a wrong position (off by one), which is corrected below.
            applicableRules.sort(compareDates);

            //If there are not enough past DST rules...
            if (applicableRules.indexOf(date) < 2) {
                applicableRules = applicableRules.concat(findApplicableRules(year - 1, _this.rules[ruleset]));
                applicableRules.sort(compareDates);
            }
            var pinpoint = applicableRules.indexOf(date);
            if (pinpoint > 1 && compareDates(date, applicableRules[pinpoint - 1], applicableRules[pinpoint - 2][1]) < 0) {
                //The previous rule does not really apply, take the one before that.
                return applicableRules[pinpoint - 2][1];
            } else if (pinpoint > 0 && pinpoint < applicableRules.length - 1 && compareDates(date, applicableRules[pinpoint + 1], applicableRules[pinpoint - 1][1]) > 0) {

                //The next rule does already apply, take that one.
                return applicableRules[pinpoint + 1][1];
            } else if (pinpoint === 0) {
                //No applicable rule found in this and in previous year.
                return null;
            }
            return applicableRules[pinpoint - 1][1];
        }

        function getAdjustedOffset(off, rule) {
            return -Math.ceil(rule[6] - off);
        }

        function getAbbreviation(zone, rule) {
            var res;
            var base = zone[2];
            if (base.indexOf('%s') > -1) {
                var repl;
                if (rule) {
                    repl = rule[7] === '-' ? '' : rule[7];
                }
                //FIXME: Right now just falling back to Standard --
                // apparently ought to use the last valid rule,
                // although in practice that always ought to be Standard
                else {
                    repl = 'S';
                }
                res = base.replace('%s', repl);
            }
            else if (base.indexOf('/') > -1) {
                //Chose one of two alternative strings.
                res = base.split("/", 2)[rule[6] ? 1 : 0];
            } else {
                res = base;
            }
            return res;
        }

        this.zoneFileBasePath;
        this.zoneFiles = ['africa', 'antarctica', 'asia', 'australasia', 'backward', 'etcetera', 'europe', 'northamerica', 'pacificnew', 'southamerica'];
        this.loadingSchemes = {
            PRELOAD_ALL: 'preloadAll',
            LAZY_LOAD: 'lazyLoad',
            MANUAL_LOAD: 'manualLoad'
        };
        this.loadingScheme = this.loadingSchemes.LAZY_LOAD;
        this.loadedZones = {};
        this.zones = {};
        this.rules = {};

        this.init = function (o) {
            var opts = { async: true }
                , def = this.defaultZoneFile = this.loadingScheme === this.loadingSchemes.PRELOAD_ALL
                    ? this.zoneFiles
                    : 'northamerica'
                , done = 0
                , callbackFn;
            //Override default with any passed-in opts
            for (var p in o) {
                opts[p] = o[p];
            }
            if (typeof def === 'string') {
                return this.loadZoneFile(def, opts);
            }
            //Wraps callback function in another one that makes
            // sure all files have been loaded.
            callbackFn = opts.callback;
            opts.callback = function () {
                done++;
                (done === def.length) && typeof callbackFn === 'function' && callbackFn();
            };
            for (var i = 0; i < def.length; i++) {
                this.loadZoneFile(def[i], opts);
            }
        };

        //Get the zone files via XHR -- if the sync flag
        // is set to true, it's being called by the lazy-loading
        // mechanism, so the result needs to be returned inline.
        this.loadZoneFile = function (fileName, opts) {
            if (typeof this.zoneFileBasePath === 'undefined') {
                throw new Error('Please define a base path to your zone file directory -- timezoneJS.timezone.zoneFileBasePath.');
            }
            //Ignore already loaded zones.
            if (this.loadedZones[fileName]) {
                return;
            }
            this.loadedZones[fileName] = true;
            return builtInLoadZoneFile(fileName, opts);
        };
        this.loadZoneJSONData = function (url, sync) {
            var processData = function (data) {
                data = eval('(' + data + ')');
                for (var z in data.zones) {
                    _this.zones[z] = data.zones[z];
                }
                for (var r in data.rules) {
                    _this.rules[r] = data.rules[r];
                }
            };
            return sync
                ? processData(_this.transport({ url: url, async: false }))
                : _this.transport({ url: url, success: processData });
        };
        this.loadZoneDataFromObject = function (data) {
            if (!data) {
                return;
            }
            for (var z in data.zones) {
                _this.zones[z] = data.zones[z];
            }
            for (var r in data.rules) {
                _this.rules[r] = data.rules[r];
            }
        };
        this.getAllZones = function () {
            var arr = [];
            for (var z in this.zones) {
                arr.push(z);
            }
            return arr.sort();
        };
        this.parseZones = function (str) {
            var lines = str.split('\n')
                , arr = []
                , chunk = ''
                , l
                , zone = null
                , rule = null;
            for (var i = 0; i < lines.length; i++) {
                l = lines[i];
                if (l.match(/^\s/)) {
                    l = "Zone " + zone + l;
                }
                l = l.split("#")[0];
                if (l.length > 3) {
                    arr = l.split(/\s+/);
                    chunk = arr.shift();
                    //Ignore Leap.
                    switch (chunk) {
                        case 'Zone':
                            zone = arr.shift();
                            if (!_this.zones[zone]) {
                                _this.zones[zone] = [];
                            }
                            if (arr.length < 3) break;
                            //Process zone right here and replace 3rd element with the processed array.
                            arr.splice(3, arr.length, processZone(arr));
                            if (arr[3]) arr[3] = Date.UTC.apply(null, arr[3]);
                            arr[0] = -getBasicOffset(arr[0]);
                            _this.zones[zone].push(arr);
                            break;
                        case 'Rule':
                            rule = arr.shift();
                            if (!_this.rules[rule]) {
                                _this.rules[rule] = [];
                            }
                            //Parse int FROM year and TO year
                            arr[0] = parseInt(arr[0], 10);
                            arr[1] = parseInt(arr[1], 10) || arr[1];
                            //Parse time string AT
                            arr[5] = parseTimeString(arr[5]);
                            //Parse offset SAVE
                            arr[6] = getBasicOffset(arr[6]);
                            _this.rules[rule].push(arr);
                            break;
                        case 'Link':
                            //No zones for these should already exist.
                            if (_this.zones[arr[1]]) {
                                throw new Error('Error with Link ' + arr[1] + '. Cannot create link of a preexisted zone.');
                            }
                            //Create the link.
                            _this.zones[arr[1]] = arr[0];
                            break;
                    }
                }
            }
            return true;
        };
        //Expose transport mechanism and allow overwrite.
        this.transport = _transport;
        this.getTzInfo = function (dt, tz, isUTC) {
            //Lazy-load any zones not yet loaded.
            if (this.loadingScheme === this.loadingSchemes.LAZY_LOAD) {
                //Get the correct region for the zone.
                var zoneFile = getRegionForTimezone(tz);
                if (!zoneFile) {
                    throw new Error('Not a valid timezone ID.');
                }
                if (!this.loadedZones[zoneFile]) {
                    //Get the file and parse it -- use synchronous XHR.
                    this.loadZoneFile(zoneFile);
                }
            }
            var z = getZone(dt, tz);
            var off = z[0];
            //See if the offset needs adjustment.
            var rule = getRule(dt, z, isUTC);
            if (rule) {
                off = getAdjustedOffset(off, rule);
            }
            var abbr = getAbbreviation(z, rule);
            return { tzOffset: off, tzAbbr: abbr };
        };
    };
}).call(this);
